Sites like Zhihu rotate hot-topic text into the search input on a
timer, pausing only when they see real keydown/keyup events. The old
path set `el.value = text` and dispatched a synthetic `input` event;
no keystroke events fired, so the rotator kept ticking and clobbered
typed text during the LLM turn gap — the Zhihu-search-AI bug.

performKeyboardInput now:
 - focuses and clears the editable via JS (keeps existing activation
   helpers for labels and shadow roots)
 - types each character via Input.dispatchKeyEvent, so keydown, input,
   and keyup all flow through Chromium's native input pipeline. A US
   keyboard layout table covers letters, digits, space, and ~30
   punctuation/shifted symbols with correct DOM code and virtual key;
   non-ASCII falls back to `char` insertion.
 - verifies document.activeElement actually landed on (or inside) the
   target before handing off to CDP, failing loudly otherwise.
 - re-runs validateCachedElement during readback so a rerendered
   replacement node surfaces as stale instead of phantom success.

Verified end-to-end against Zhihu (search "AI" now submits "AI") and
DuckDuckGo with punctuation ("C++ @2026.04 vs. Rust?" round-trips
through the URL unchanged). Also re-ran the full 4-model eval (140
runs): qwen3.6-flash gained +10.8 task points and ran ~30s faster
per test, consistent with no longer losing time to rotator clobber.

Map pins (SVG <circle>/<rect> children of <g> inside <svg>), icon
toggles drawn directly in SVG, and chart markers can have their own
cursor:pointer and click listener without an HTML wrapper. The prior
detection pipeline dropped them on two gates:

1. isMeaningfulPointerCandidate rejected non-HTMLElements outright,
   so the pointer-cursor signal never registered for SVG leaves.
2. resolveClickableCandidate walked from an SVG element to its
   parentElement and bailed when that parent was also an SVG (as it
   always is for pins inside <g>-wrappers).

Fix:
- Accept SVGElement in isMeaningfulPointerCandidate; the size/area
  heuristics below already work on SVG bboxes (the
  SVGGraphicsElement.prototype.getBoundingClientRect patch at the top
  of the scan makes layout reads fast and consistent).
- When resolveClickableCandidate is handed an SVG graphics element
  that classifies as clickable on its own, return it directly as a
  standalone candidate. Fall through to the existing HTML-ancestor
  walk only for decorative SVG children of interactive HTML wrappers
  (<button><svg>…</svg></button>) — behaviour unchanged for that case.

Surfaced by the mapquest_nearby_pins evaluation test: pins rendered
as <circle class="map-pin"> with cursor:pointer + addEventListener
click were never picked up in the highlight scan, so the agent had
no element_id to target. All 4 qwen models scored 4.5/12 on that
test both on main and on branch, a stable 4.5-point floor that the
pin-detection gap explained.

Verified end-to-end via open-browser skill against the mapquest
mock site (served with the shared /js/tracker.js dependency so the
page actually renders pins): 8 pins detected, agent clicks the
Space Needle pin and the place-detail panel opens with name, rating,
hours, address, website, phone. Existing highlight-detection /
highlight-any / element-actions-regression suites all green.

The single file under local_vendor/openhands-sdk/ was unreferenced by
pyproject.toml, uv.lock, or any source — the SDK is consumed via the uv
git source, not a local vendor tree.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…inal keyframe on stop

Two independent wins for the compiler-agent's trace view, both surfaced
by recording aab8711b on the latest session:

1. Merge consecutive keystrokes.

   The recorder emits one `input` event per keystroke (plus
   `beforeinput` on contenteditable rich editors), so a 10-letter title
   produces 10+ near-identical events. On a real Yuque recording this
   turned a 266-event trace into 123 input events out of the total —
   every actual action (click, navigation, drag) was buried in typing
   noise.

   New helper `coalesce_typing_events` in workflow_compiler walks events
   in order; runs of consecutive `input`/`change`/`beforeinput` on the
   same element identity collapse into the last event in the run. The
   survivor carries the final text snapshot and picks up
   `coalescedCount` + `coalescedEventIndexes` annotations so the agent
   can drill back into any single keystroke via `event_detail`.

   Identity uses a new `_stable_element_identity` (selector + ARIA label
   + placeholder + container selector) — the existing `_element_identity`
   folds `element.text` into the hash, which is exactly what changes
   between keystrokes and defeats coalescing.

   `TraceViewerExecutor` now applies the coalescer in its constructor
   and presents the folded list via `events`/`summary`; `_events_by_index`
   still indexes the full raw list so `event_detail` works on absorbed
   indexes. `summary` calls out the raw→coalesced delta and each listed
   event gets a `[coalesced ×N]` tag when more than one was folded.

   Smoke-tested against recording 589eb0e8 (266 events, 123 inputs):
   after coalescing, 7 input events remain (one per typing burst on one
   element); non-typing events are untouched.

2. Capture a final keyframe on `recording_stopped`.

   `stopRecording` picks the scope's currently-active tab (falling back
   to any recordable tab in scope) and calls `buildRecordingKeyframe`
   before the debugger session is torn down. The keyframe rides on the
   `recording_stopped` event's `event_data.keyframe` slot, so the
   existing trace viewer keyframe-count + `event_detail` image display
   works without further changes. Failures are logged and swallowed —
   stop must never block on screenshot flakiness.

Tests: new `test_coalesce_typing_events.py` (8 cases covering folding,
run separation, keyframe promotion, order preservation); existing
`test_workflow_compiler_contenteditable.py` still green; recorder
bun-test suite still passes with the new stop-time keyframe call
(gracefully no-ops when Chrome debugger API isn't available in the
harness).

…t in trace_viewer

Three layered fixes so that text typed into rich-text editor bodies (Yuque/
Lake editor and similar) reaches the compiler agent, plus an eval fixture
pinning the regression and SKILL.md improvements that surfaced from running
the recording→compile pipeline end-to-end.

Recorder (extension/src/content/index.ts):
- input listener now also matches contenteditable targets, with a new
  isContentEditableElement helper and a getContentEditableText helper that
  populates the serialized value from innerText.
- New beforeinput listener for contenteditable targets only — covers rich
  editors (Lake, ProseMirror, Slate, Lexical, TipTap) that intercept
  keydown + preventDefault and synthesize edits via their own DOM model
  so native input events never fire on the body. The DOM snapshot is
  deferred to a microtask so it reflects the post-mutation state.

Compiler view (server/core/compiler_agent.py):
- _format_value_with_tail renders long input values with both ends
  visible and the middle elided as "<head> ...(N more chars; use
  event_detail)... <tail>". Replaces the hard 80-char head-only
  truncation that hid user-typed instructions appearing late in the
  value.
- _handle_normalized_steps now surfaces a "field <selector>
  final_value=..." line per anchor for [form] steps, picking the
  latest snapshot in event order. The previous summary showed only
  step type and event indexes, hiding the actual typed content.

Eval fixture (eval/routine_eval/fixtures/github-trending-contenteditable-question/):
- Real recording (5c5cf4f5) where the user types instructions into the
  Yuque body for the replay agent to follow. expectations.yaml encodes
  the position-vs-identity ambiguity and forbids asking the user to
  retype visible content while leaving intent-clarification questions
  legitimate.

Tests (server/tests/unit/):
- test_workflow_compiler_contenteditable.py covers the html-fallback
  path in _extract_input_value (introduced earlier in this branch).
- test_compiler_agent_value_view.py covers _format_value_with_tail
  edge cases and the latest-in-event-order field picker, including
  paste-then-trim / clear-and-rewrite flows where longest-wins would
  surface stale text.

SKILL.md (skill/claude/ob-routines/SKILL.md):
- tmux launch keeps the window alive via "exec zsh" so [compiler:saved]
  and [compile-done] markers don't get lost when the window auto-closes
  on python exit.
- Monitor template detects pane-gone and emits a terminal event so a
  silent dead-pane poll loop is no longer possible.
- Adds a verify-after-saved step using list_routines.py.
- Quality-gate section now states explicitly that the gate reasoning
  is Claude's judgment, must be written as user-visible text before
  pressing Enter, and the compiler's wrap-up message is not a
  substitute.

Pin agent-sdk to commit 32e6edba (matching prompt update for the new
trace_viewer rendering).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Full eval on feat/compiler-default-alias with qwen3.{5,6}-{plus,flash}-fast.
105/140 passed (75.0%), raw score delta −21.8 vs main (−1.8%); infra-adjusted
−4.8 (−0.4%). See tmp/OBSERVATION_REPORT_20260424_100152.md for full
root-cause analysis (T1 SVG-clickable trade-off, T2 please_help_me eval
killswitch, flash instruction drift, etc).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…alias

The canonical version-controlled report at
`eval/routine_eval/compile_evaluation_report.json` is overwritten by every
run, so a multi-model eval loop (4 -fast models) ends up keeping only the
last run's data — which happened to be the weakest model and looked like
"all cases failed". When `--compile-alias` is given, write the canonical
copy to `compile_evaluation_report_<alias>.json` instead so each model in a
loop preserves its own baseline. The unsuffixed path is preserved as the
default for runs that use the server's default alias, so existing dashboards
and CI flows are unaffected.

Also commits the four per-model reports from a fresh rerun on 2026-04-24:

  qwen35plus-fast  : 1/3 pass  (intent_match peaks at 1.0 on the new
                                contenteditable fixture, confirming the
                                trace_viewer fixes from 8f11aa6 reach the LLM)
  qwen36plus-fast  : 2/3 pass
  qwen35flash-fast : 0/3 pass  (consistent across runs — flash drift)
  qwen36flash-fast : 1/3 pass

Per-test failure breakdown is in tmp/observation_notes_20260424_100152.md
plus the chat record from the rerun.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Pre-commit autoformatted black (Python) and prettier (TS) over the files
touched on this branch. No semantic changes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>